Internet Info 1993/Internet Info CD-ROM (Walnut Creek) (1993).iso/networking/terms/kermit/b/mpker.glo

Text File | 1988-08-16 | 55.4 KB | 1,708 lines

R DATE F I=0:0 R GREF Q:GREF=""  R DATA S @GREF=DATA
22 MAR 84, 16:52
^ZKRX
KERMIT reference files
^ZKRX("?","CONNECT","1")
MUMPS line number or mnemonic
^ZKRX("?","CONNECT","2")
or confirm to connect to line selected with SET LINE command
^ZKRX("?","GET","1")
remote file specification
^ZKRX("?","SEND","1")
input file spec (possibly wild)
^ZKRX("?","SET","DELAY","1")
decimal number of seconds
^ZKRX("?","SET","ESCAPE","1")
Mnemonic for a control character
^ZKRX("?","SET","ESCAPE","2")
like '^A' for control-A, etc., or '^[', '^', '^]', '^^', or '^_'.
^ZKRX("?","SET","LINE","1")
tty number or mnemonic to transfer over
^ZKRX("?","SET","LINE","2")
or confirm to reset to the terminal
^ZKRX("?","SET","PAUSE","1")
number of seconds, 0 or more
^ZKRX("?","SET","RECEIVE","PACKET-LENGTH","1")
decimal number between 10 and 90
^ZKRX("?","SET","RECEIVE","QUOTE","1")
a printable character
^ZKRX("?","SET","RECEIVE","START-OF-PACKET","1")
Mnemonic for a control character
^ZKRX("?","SET","RECEIVE","START-OF-PACKET","2")
like '^A' for control-A, etc., or '^[', '^', '^]', '^^', or '^_'.
^ZKRX("?","SET","RECEIVE","TIMEOUT","1")
number of seconds, 0 or more
^ZKRX("?","SET","RETRY","1")
number of retries, 0 or more
^ZKRX("?","SET","SEND","END-OF-LINE","1")
Mnemonic for a control character
^ZKRX("?","SET","SEND","END-OF-LINE","2")
like '^A' for control-A, etc., or '^[', '^', '^]', '^^', or '^_'.
^ZKRX("?","SET","SEND","PACKET-LENGTH","1")
decimal number between 10 and 90
^ZKRX("?","SET","SEND","QUOTE","1")
a character in the range ! to > or ` to ~
^ZKRX("?","SET","SEND","START-OF-PACKET","1")
Mnemonic for a control character
^ZKRX("?","SET","SEND","START-OF-PACKET","2")
like '^A' for control-A, etc., or '^[', '^', '^]', '^^', or '^_'.
^ZKRX("?","SET","SEND","TIMEOUT","1")
number of seconds, 0 or more
^ZKRX("COMMAND","BYE")
1
^ZKRX("COMMAND","CONNECT")
1
^ZKRX("COMMAND","CONNECT","~TTY")
1
^ZKRX("COMMAND","EXIT")
1
^ZKRX("COMMAND","FINISH")
1
^ZKRX("COMMAND","GET","~RFSPEC")
1
^ZKRX("COMMAND","HELP")
1
^ZKRX("COMMAND","HELP","BYE")
1
^ZKRX("COMMAND","HELP","CONNECT")
1
^ZKRX("COMMAND","HELP","EXIT")
1
^ZKRX("COMMAND","HELP","FINISH")
1
^ZKRX("COMMAND","HELP","GET")
1
^ZKRX("COMMAND","HELP","HELP")
1
^ZKRX("COMMAND","HELP","KERMIT")
1
^ZKRX("COMMAND","HELP","MUMPS")
1
^ZKRX("COMMAND","HELP","QUIT")
1
^ZKRX("COMMAND","HELP","RECEIVE")
1
^ZKRX("COMMAND","HELP","RESET")
1
^ZKRX("COMMAND","HELP","SEND")
1
^ZKRX("COMMAND","HELP","SERVER")
1
^ZKRX("COMMAND","HELP","SET")
1
^ZKRX("COMMAND","HELP","SET","ABORTED-FILE")
1
^ZKRX("COMMAND","HELP","SET","BAUD")
1
^ZKRX("COMMAND","HELP","SET","DEBUGGING")
1
^ZKRX("COMMAND","HELP","SET","DELAY")
1
^ZKRX("COMMAND","HELP","SET","DUPLEX")
1
^ZKRX("COMMAND","HELP","SET","ESCAPE")
1
^ZKRX("COMMAND","HELP","SET","FILE-WARNING")
1
^ZKRX("COMMAND","HELP","SET","LINE")
1
^ZKRX("COMMAND","HELP","SET","PARITY")
1
^ZKRX("COMMAND","HELP","SET","PAUSE")
1
^ZKRX("COMMAND","HELP","SET","RECEIVE")
1
^ZKRX("COMMAND","HELP","SET","RECEIVE","PACKET-LENGTH")
1
^ZKRX("COMMAND","HELP","SET","RECEIVE","START-OF-PACKET")
1
^ZKRX("COMMAND","HELP","SET","RECEIVE","TIMEOUT")
1
^ZKRX("COMMAND","HELP","SET","RETRY")
1
^ZKRX("COMMAND","HELP","SET","SEND")
1
^ZKRX("COMMAND","HELP","SET","SEND","END-OF-LINE")
1
^ZKRX("COMMAND","HELP","SET","SEND","PACKET-LENGTH")
1
^ZKRX("COMMAND","HELP","SET","SEND","QUOTE")
1
^ZKRX("COMMAND","HELP","SET","SEND","START-OF-PACKET")
1
^ZKRX("COMMAND","HELP","SET","SEND","TIMEOUT")
1
^ZKRX("COMMAND","HELP","SHOW")
1
^ZKRX("COMMAND","HELP","STATISTICS")
1
^ZKRX("COMMAND","MUMPS")
1
^ZKRX("COMMAND","QUIT")
1
^ZKRX("COMMAND","RECEIVE")
1
^ZKRX("COMMAND","RESET")
1
^ZKRX("COMMAND","SEND","~FSPECW")
1
^ZKRX("COMMAND","SERVER")
1
^ZKRX("COMMAND","SET","ABORTED-FILE","DISCARD")
1
^ZKRX("COMMAND","SET","ABORTED-FILE","KEEP")
1
^ZKRX("COMMAND","SET","BAUD","50")
1
^ZKRX("COMMAND","SET","BAUD","75")
1
^ZKRX("COMMAND","SET","BAUD","110")
1
^ZKRX("COMMAND","SET","BAUD","134.5")
1
^ZKRX("COMMAND","SET","BAUD","150")
1
^ZKRX("COMMAND","SET","BAUD","300")
1
^ZKRX("COMMAND","SET","BAUD","600")
1
^ZKRX("COMMAND","SET","BAUD","1200")
1
^ZKRX("COMMAND","SET","BAUD","1800")
1
^ZKRX("COMMAND","SET","BAUD","2400")
1
^ZKRX("COMMAND","SET","BAUD","4800")
1
^ZKRX("COMMAND","SET","BAUD","9600")
1
^ZKRX("COMMAND","SET","BAUD","19200")
1
^ZKRX("COMMAND","SET","DEBUGGING","OFF")
1
^ZKRX("COMMAND","SET","DEBUGGING","ON")
1
^ZKRX("COMMAND","SET","DELAY","~SEC")
1
^ZKRX("COMMAND","SET","DUPLEX","FULL")
1
^ZKRX("COMMAND","SET","DUPLEX","HALF")
1
^ZKRX("COMMAND","SET","ESCAPE","~CTRL")
1
^ZKRX("COMMAND","SET","FILE-WARNING","OFF")
1
^ZKRX("COMMAND","SET","FILE-WARNING","ON")
1
^ZKRX("COMMAND","SET","LINE")
1
^ZKRX("COMMAND","SET","LINE","~TTY")
1
^ZKRX("COMMAND","SET","PARITY","EVEN")
1
^ZKRX("COMMAND","SET","PARITY","MARK")
1
^ZKRX("COMMAND","SET","PARITY","NONE")
1
^ZKRX("COMMAND","SET","PARITY","ODD")
1
^ZKRX("COMMAND","SET","PARITY","SPACE")
1
^ZKRX("COMMAND","SET","PAUSE","~SEC")
1
^ZKRX("COMMAND","SET","RECEIVE","PACKET-LENGTH","~PLEN")
1
^ZKRX("COMMAND","SET","RECEIVE","START-OF-PACKET","~CTRL")
1
^ZKRX("COMMAND","SET","RECEIVE","TIMEOUT","~SEC")
1
^ZKRX("COMMAND","SET","RETRY")
1
^ZKRX("COMMAND","SET","RETRY","~TRY")
1
^ZKRX("COMMAND","SET","SEND","END-OF-LINE","~CTRL")
1
^ZKRX("COMMAND","SET","SEND","PACKET-LENGTH","~PLEN")
1
^ZKRX("COMMAND","SET","SEND","QUOTE","~QUOTE")
1
^ZKRX("COMMAND","SET","SEND","START-OF-PACKET","~CTRL")
1
^ZKRX("COMMAND","SET","SEND","TIMEOUT","~SEC")
1
^ZKRX("COMMAND","SHOW")
1
^ZKRX("COMMAND","STATISTICS")
1
^ZKRX("GUIDE","BYE")
to remote server
^ZKRX("GUIDE","CONNECT")
to tty
^ZKRX("GUIDE","EXIT")
from Kermit
^ZKRX("GUIDE","FINISH")
remote server operation
^ZKRX("GUIDE","GET")
remote files
^ZKRX("GUIDE","HELP")
about
^ZKRX("GUIDE","QUIT")
from Kermit
^ZKRX("GUIDE","SEND")
from files
^ZKRX("GUIDE","SET","BAUD")
to
^ZKRX("GUIDE","SET","DELAY")
to
^ZKRX("GUIDE","SET","DUPLEX")
to
^ZKRX("GUIDE","SET","ESCAPE")
character for connect to
^ZKRX("GUIDE","SET","LINE")
to tty
^ZKRX("GUIDE","SET","PARITY")
to
^ZKRX("GUIDE","SET","PAUSE")
to
^ZKRX("GUIDE","SET","RECEIVE","PACKET-LENGTH")
to
^ZKRX("GUIDE","SET","RECEIVE","START-OF-PACKET")
to
^ZKRX("GUIDE","SET","RECEIVE","TIMEOUT")
to
^ZKRX("GUIDE","SET","SEND","END-OF-LINE")
to
^ZKRX("GUIDE","SET","SEND","PACKET-LENGTH")
to
^ZKRX("GUIDE","SET","SEND","QUOTE")
to
^ZKRX("GUIDE","SET","SEND","START-OF-PACKET")
to
^ZKRX("GUIDE","SET","SEND","TIMEOUT")
to
^ZKRX("GUIDE","SHOW")
Kermit parameters
^ZKRX("GUIDE","STATUS")
of Kermit
^ZKRX("HELP","0")
13
^ZKRX("HELP","1")
KERMIT is a program that transfer files between computers, using
^ZKRX("HELP","2")
asynchronous communications lines.  For a general description of
^ZKRX("HELP","3")
the program, enter 'HELP KERMIT'.  For a description of each command,
^ZKRX("HELP","4")
enter 'HELP ', followed by the command name, e.g. 'HELP SEND' for
^ZKRX("HELP","5")
information on the SEND command.  For a list of commands, enter a
^ZKRX("HELP","6")
'?' only.
^ZKRX("HELP","7")

^ZKRX("HELP","8")
>>>> To leave Kermit-M, enter 'QUIT' or 'EXIT'. <<<<
^ZKRX("HELP","9")

^ZKRX("HELP","10")
The Kermit-M command parser follows the TOPS-20 style: <RETURN> ends
^ZKRX("HELP","11")
the entry of a complete command; '?' at any point shows you the
^ZKRX("HELP","12")
possible completions of a command;  <ESC> will complete the
^ZKRX("HELP","13")
current command word, if possible.
^ZKRX("HELP","BYE","0")
9
^ZKRX("HELP","BYE","1")
BYE
^ZKRX("HELP","BYE","2")

^ZKRX("HELP","BYE","3")
When running as a local Kermit, talking to a Kermit server over a TTY line
^ZKRX("HELP","BYE","4")
specified in a SET LINE or CONNECT command, use the BYE command to shut down
^ZKRX("HELP","BYE","5")
and log out the server.  This will also exit from the local Kermit.
^ZKRX("HELP","BYE","6")

^ZKRX("HELP","BYE","7")
Use the FINISH command to shut down the remote Server, but leave the
^ZKRX("HELP","BYE","8")
remote Kermit in its command mode, and leave this local Kermit in
^ZKRX("HELP","BYE","9")
command mode.
^ZKRX("HELP","CONNECT","0")
22
^ZKRX("HELP","CONNECT","1")
CONNECT [port number or mnemonic]
^ZKRX("HELP","CONNECT","2")

^ZKRX("HELP","CONNECT","3")
Establish a terminal connection to another system.  If you have
^ZKRX("HELP","CONNECT","4")
previously specified a port with the SET LINE command, the
^ZKRX("HELP","CONNECT","5")
CONNECT command with no argument will work.  Otherwise, you must
^ZKRX("HELP","CONNECT","6")
also specify a port.  The following formats are accepted:
^ZKRX("HELP","CONNECT","7")

^ZKRX("HELP","CONNECT","8")
  decimal number -- a MUMPS port number.  The remote system must
^ZKRX("HELP","CONNECT","9")
                    be physically connected to that port.
^ZKRX("HELP","CONNECT","10")
  system mnemonic -- an abbreviation for a remote system.  If this
^ZKRX("HELP","CONNECT","11")
                    mnemonic makes sense to Kermit, it will initiate
^ZKRX("HELP","CONNECT","12")
                    a connection to the remote system.
^ZKRX("HELP","CONNECT","13")

^ZKRX("HELP","CONNECT","14")
For example, suppose the Cornell Computer Service's DECSYSTEM-20 is
^ZKRX("HELP","CONNECT","15")
known as 'DEC20'.  If you enter 'CONNECT DEC20', Kermit will look up
^ZKRX("HELP","CONNECT","16")
the telephone number, select an outdialing modem port, and try to
^ZKRX("HELP","CONNECT","17")
make the connection.  See your system manager or local users' guide
^ZKRX("HELP","CONNECT","18")
for a list of system mnemonics.
^ZKRX("HELP","CONNECT","19")

^ZKRX("HELP","CONNECT","20")
Once you are connected, you are conversing with the remote system.  Get
^ZKRX("HELP","CONNECT","21")
back to Kermit-M by typing the 'escape' character (usually ^Y), followed
^ZKRX("HELP","CONNECT","22")
by a 'C'.
^ZKRX("HELP","EXIT","0")
5
^ZKRX("HELP","EXIT","1")
EXIT
^ZKRX("HELP","EXIT","2")

^ZKRX("HELP","EXIT","3")
Done with Kermit-M.  This will 'quit' your MUMPS job.  If you were
^ZKRX("HELP","EXIT","4")
in programmer mode, you'll go back there; if you were in user mode,
^ZKRX("HELP","EXIT","5")
you will be halted.
^ZKRX("HELP","FINISH","0")
8
^ZKRX("HELP","FINISH","1")
FINISH
^ZKRX("HELP","FINISH","2")

^ZKRX("HELP","FINISH","3")
When running as a local Kermit, talking to a remote Server,
^ZKRX("HELP","FINISH","4")
use the FINISH command to shut down the Server without logging out
^ZKRX("HELP","FINISH","5")
Kermit on the remote end.  This also leaves the local Kermit at
^ZKRX("HELP","FINISH","6")
the 'Kermit-M>' prompt.
^ZKRX("HELP","FINISH","7")

^ZKRX("HELP","FINISH","8")
Use BYE to log out the remote and local Kermits.
^ZKRX("HELP","GET","0")
19
^ZKRX("HELP","GET","1")
GET remote-filespec
^ZKRX("HELP","GET","2")

^ZKRX("HELP","GET","3")
This command asks a remote Kermit server to send you the named files.
^ZKRX("HELP","GET","4")
Before issuing this command, you must have already CONNECTed to the
^ZKRX("HELP","GET","5")
remote host, and issued the SERVER command there, to start the remote
^ZKRX("HELP","GET","6")
Kermit server.
^ZKRX("HELP","GET","7")

^ZKRX("HELP","GET","8")
The remote-filespec is not validated at the local end, since its validity
^ZKRX("HELP","GET","9")
can only be determined by the system with the files, that is, the remote
^ZKRX("HELP","GET","10")
system.  You will get an error message if it's an illegal filespec.
^ZKRX("HELP","GET","11")

^ZKRX("HELP","GET","12")
As files arrive, their names will be displayed on your screen.
^ZKRX("HELP","GET","13")

^ZKRX("HELP","GET","14")
If the remote KERMIT is not capable of server functions, then you will
^ZKRX("HELP","GET","15")
probably get an error message like 'Illegal packet type'.  In this case,
^ZKRX("HELP","GET","16")
you must CONNECT to the remote Kermit, issue the SEND command there,
^ZKRX("HELP","GET","17")
escape back to this local Kermit, and issue a RECEIVE command.
^ZKRX("HELP","GET","18")

^ZKRX("HELP","GET","19")
The GET command has no effect when running as a remote Kermit.
^ZKRX("HELP","HELP","0")
15
^ZKRX("HELP","HELP","1")
HELP [topic]
^ZKRX("HELP","HELP","2")

^ZKRX("HELP","HELP","3")
Typing HELP with no further argument will get you a brief summary of
^ZKRX("HELP","HELP","4")
Kermit-M and its commands.  Typing HELP, followed by a command, will
^ZKRX("HELP","HELP","5")
get you detailed information about the specific command.  For example,
^ZKRX("HELP","HELP","6")

^ZKRX("HELP","HELP","7")
  help send
^ZKRX("HELP","HELP","8")

^ZKRX("HELP","HELP","9")
will tell you all about the SEND command.
^ZKRX("HELP","HELP","10")

^ZKRX("HELP","HELP","11")
  help ?
^ZKRX("HELP","HELP","12")

^ZKRX("HELP","HELP","13")
will list all the available commands.
^ZKRX("HELP","HELP","14")

^ZKRX("HELP","HELP","15")
See the Kermit Users' Guide for examples of sample Kermit sessions.
^ZKRX("HELP","KERMIT","0")
46
^ZKRX("HELP","KERMIT","1")
KERMIT is a file transfer protocol for use over an asynchronous serial
^ZKRX("HELP","KERMIT","2")
telecommunication line.  Files are broken up into "packets" with checksums and
^ZKRX("HELP","KERMIT","3")
other control information to ensure (with high probability) error-free and
^ZKRX("HELP","KERMIT","4")
complete transmission.
^ZKRX("HELP","KERMIT","5")

^ZKRX("HELP","KERMIT","6")
Kermit-M is the KERMIT implementation for systems running 1982 ANSI Standard
^ZKRX("HELP","KERMIT","7")
MUMPS.  There are different implementations of MUMPS that all meet the
^ZKRX("HELP","KERMIT","8")
1982 Standard; this version of Kermit-M has been tailored for InterSystems
^ZKRX("HELP","KERMIT","9")
M/11.
^ZKRX("HELP","KERMIT","10")

^ZKRX("HELP","KERMIT","11")
Kermit-M can be run "locally" with a remote KERMIT on the other end of an
^ZKRX("HELP","KERMIT","12")
assigned telecommunications line (e.g. over an autodialer connection), or
^ZKRX("HELP","KERMIT","13")
"remotely" from another computer (e.g. a microcomputer).
^ZKRX("HELP","KERMIT","14")

^ZKRX("HELP","KERMIT","15")
You can run Kermit-M interactively by typing repeated commands in response to
^ZKRX("HELP","KERMIT","16")
its "Kermit-M>" prompt, or you can run it as a remote server.
^ZKRX("HELP","KERMIT","17")

^ZKRX("HELP","KERMIT","18")
Kermit-M commands -- optional parts are in [brackets]:
^ZKRX("HELP","KERMIT","19")

^ZKRX("HELP","KERMIT","20")
* For exchanging files:        SEND file(s)
^ZKRX("HELP","KERMIT","21")
                               RECEIVE
^ZKRX("HELP","KERMIT","22")
                               GET remote-file(s)
^ZKRX("HELP","KERMIT","23")

^ZKRX("HELP","KERMIT","24")
* For acting as local Kermit:  SET LINE, SET PARITY, DUPLEX, ESCAPE
^ZKRX("HELP","KERMIT","25")
                               CONNECT [line]
^ZKRX("HELP","KERMIT","26")

^ZKRX("HELP","KERMIT","27")
* For acting as a server:      SERVER
^ZKRX("HELP","KERMIT","28")

^ZKRX("HELP","KERMIT","29")
* For talking to a server:     BYE, FINISH, GET remote-file(s), SEND file(s)
^ZKRX("HELP","KERMIT","30")

^ZKRX("HELP","KERMIT","31")
* Setting nonstandard transmission and file parameters:
^ZKRX("HELP","KERMIT","32")
     SET DEBUGGING, DELAY, ESCAPE, PARITY, PAUSE
^ZKRX("HELP","KERMIT","33")
     SET RECEIVE PACKET-LENGTH, START-OF-PACKET, TIMEOUT
^ZKRX("HELP","KERMIT","34")
     SET SEND END-OF-LINE, PACKET-LENGTH, START-OF-PACKET, QUOTE, TIMEOUT
^ZKRX("HELP","KERMIT","35")

^ZKRX("HELP","KERMIT","36")
* Getting information:        HELP [topic], STATUS, SHOW
^ZKRX("HELP","KERMIT","37")

^ZKRX("HELP","KERMIT","38")
* Leaving a local Kermit:     QUIT, EXIT
^ZKRX("HELP","KERMIT","39")

^ZKRX("HELP","KERMIT","40")
* Stopping a remote Kermit:   BYE, FINISH
^ZKRX("HELP","KERMIT","41")

^ZKRX("HELP","KERMIT","42")
* Accessing the Kermit file system, and transferring files
^ZKRX("HELP","KERMIT","43")
   to MUMPS data structures:   MUMPS
^ZKRX("HELP","KERMIT","44")

^ZKRX("HELP","KERMIT","45")
For further information, type "help" for any of the above commands, e.g.
^ZKRX("HELP","KERMIT","46")
"help set", or see the "Kermit Users Guide".
^ZKRX("HELP","MUMPS","0")
20
^ZKRX("HELP","MUMPS","1")
MUMPS
^ZKRX("HELP","MUMPS","2")

^ZKRX("HELP","MUMPS","3")
Kermit-M file system
^ZKRX("HELP","MUMPS","4")

^ZKRX("HELP","MUMPS","5")
This program provides access to the Kermit file system within the
^ZKRX("HELP","MUMPS","6")
 MUMPS environment.  Since MUMPS does not have a 'traditional' file
^ZKRX("HELP","MUMPS","7")
 system, like TOPS-20, CMS, or CP/M, Kermit must have its own file
^ZKRX("HELP","MUMPS","8")
 system.  The MUMPS command will give you 'file system' options to
^ZKRX("HELP","MUMPS","9")
 get Directories, to Copy files, to Rename files, and to Erase files.
^ZKRX("HELP","MUMPS","10")

^ZKRX("HELP","MUMPS","11")
In addition, this program provides means of transferring between the
^ZKRX("HELP","MUMPS","12")
 Kermit file structure and MUMPS data structures, namely 1) routines,
^ZKRX("HELP","MUMPS","13")
 2) globals, and 3) sequential lists.
^ZKRX("HELP","MUMPS","14")

^ZKRX("HELP","MUMPS","15")
The MUMPS command is implemented as a set of menus.  The TOPS-20 command
^ZKRX("HELP","MUMPS","16")
 style doesn't work; you have to terminate each answer with <RETURN>.
^ZKRX("HELP","MUMPS","17")
 For help at any question, you can enter ?<RETURN>.
^ZKRX("HELP","MUMPS","18")

^ZKRX("HELP","MUMPS","19")
For more information, enter the MUMPS command, and then use '?' to get
^ZKRX("HELP","MUMPS","20")
 help at each menu (MAIN, INPUT, and OUTPUT options).
^ZKRX("HELP","QUIT","0")
3
^ZKRX("HELP","QUIT","1")
QUIT
^ZKRX("HELP","QUIT","2")

^ZKRX("HELP","QUIT","3")
Synonym for EXIT.
^ZKRX("HELP","RECEIVE","0")
24
^ZKRX("HELP","RECEIVE","1")
RECEIVE
^ZKRX("HELP","RECEIVE","2")

^ZKRX("HELP","RECEIVE","3")
Receive a file or a group of files from the other host.  The name of
^ZKRX("HELP","RECEIVE","4")
each file is transmitted in a 'file header' packet before the data in
^ZKRX("HELP","RECEIVE","5")
the file, and Kermit-M stores the file under this file name.
^ZKRX("HELP","RECEIVE","6")
Several problems might arise:
^ZKRX("HELP","RECEIVE","7")

^ZKRX("HELP","RECEIVE","8")
 1) the file name might already exist on this system.  In this case,
^ZKRX("HELP","RECEIVE","9")
    the action to be taken depends on the 'file-warning' flag, which
^ZKRX("HELP","RECEIVE","10")
    you can alter with the 'SET FILE-WARNING' command.  If this flag
^ZKRX("HELP","RECEIVE","11")
    is OFF, the existing file will be (silently) overwritten.  If
^ZKRX("HELP","RECEIVE","12")
    this flag is ON, an error packet will be sent (instead of an
^ZKRX("HELP","RECEIVE","13")
    acknowledgement) to the sending Kermit; presumably this will
^ZKRX("HELP","RECEIVE","14")
    abort the transmission, at least for this file.
^ZKRX("HELP","RECEIVE","15")

^ZKRX("HELP","RECEIVE","16")
 2) the file name might be illegal in some way.  In this case, an
^ZKRX("HELP","RECEIVE","17")
    an error packet (instead of an acknowledgement) is returned to the
^ZKRX("HELP","RECEIVE","18")
    sending Kermit; presumably this will also abort the transmission.
^ZKRX("HELP","RECEIVE","19")

^ZKRX("HELP","RECEIVE","20")
If running as a local Kermit, the name of each file (and possibly its
^ZKRX("HELP","RECEIVE","21")
altered name) will be displayed as the transfer begins.  A '.' will be
^ZKRX("HELP","RECEIVE","22")
printed for every 5 data packets successfully received, and a '%' will be
^ZKRX("HELP","RECEIVE","23")
printed for every timeout or retransmission.  If running as a remote Kermit,
^ZKRX("HELP","RECEIVE","24")
you should escape back to your local Kermit and give the SEND command.
^ZKRX("HELP","RESET","0")
5
^ZKRX("HELP","RESET","1")
RESET
^ZKRX("HELP","RESET","2")

^ZKRX("HELP","RESET","3")
Reset all protocols and communications lines, and restart Kermit
^ZKRX("HELP","RESET","4")
at the command level.  This is the same as EXITing, and then
^ZKRX("HELP","RESET","5")
restarting Kermit.
^ZKRX("HELP","SEND","0")
20
^ZKRX("HELP","SEND","1")
SEND filespec
^ZKRX("HELP","SEND","2")

^ZKRX("HELP","SEND","3")
Send a file or file group from MUMPS to the other host.  The filespec
^ZKRX("HELP","SEND","4")
may contain the '*' 'wildcard' character, which substitutes for any
^ZKRX("HELP","SEND","5")
completion (including none) within each of the filename and filetuype.
^ZKRX("HELP","SEND","6")
All files matching filespec1 will be sent.  The exact name of each
^ZKRX("HELP","SEND","7")
file is passed to the other host in a file header.
^ZKRX("HELP","SEND","8")

^ZKRX("HELP","SEND","9")
For example, the filespec 'A*.D*' would match the following files:
^ZKRX("HELP","SEND","10")

^ZKRX("HELP","SEND","11")
 A.D  ;  ABC.DEF  ;  ABC.D  ;  A.DEF
^ZKRX("HELP","SEND","12")

^ZKRX("HELP","SEND","13")
The first character of the filename may be the '%' character, as in
^ZKRX("HELP","SEND","14")
MUMPS routine or global names.
^ZKRX("HELP","SEND","15")

^ZKRX("HELP","SEND","16")
If running as a local Kermit, the name of each file will be displayed on
^ZKRX("HELP","SEND","17")
your screen as the transfer of that file begins.
^ZKRX("HELP","SEND","18")

^ZKRX("HELP","SEND","19")
If running as a remote Kermit, you should escape back to your local Kermit
^ZKRX("HELP","SEND","20")
and give the RECEIVE command.
^ZKRX("HELP","SERVER","0")
13
^ZKRX("HELP","SERVER","1")
SERVER
^ZKRX("HELP","SERVER","2")

^ZKRX("HELP","SERVER","3")
Act as a server for another Kermit.  Take all further commands only from
^ZKRX("HELP","SERVER","4")
the other Kermit.  This command only works if you are running remotely
^ZKRX("HELP","SERVER","5")
(i.e. you've CONNECTed to this Kermit from your local Kermit).  After
^ZKRX("HELP","SERVER","6")
issuing this command, 'escape' back to your local Kermit, and issue the
^ZKRX("HELP","SERVER","7")
SEND, RECEIVE (CP/M) or GET (TOPS-20, MUMPS), or BYE server-oriented
^ZKRX("HELP","SERVER","8")
commands to your local Kermit.
^ZKRX("HELP","SERVER","9")

^ZKRX("HELP","SERVER","10")
Use the BYE command from your local Kermit to shut down and log out this
^ZKRX("HELP","SERVER","11")
Kermit server when you're done with it.  Another way to stop it is to
^ZKRX("HELP","SERVER","12")
CONNECT back to Kermit-M and type a CTRL/C to get back to Kermit-M command
^ZKRX("HELP","SERVER","13")
mode.
^ZKRX("HELP","SET","0")
8
^ZKRX("HELP","SET","1")
The SET command is used to change system-dependent parameters.
^ZKRX("HELP","SET","2")
Enter 'SET ?' for a list of the parameters that you can change.
^ZKRX("HELP","SET","3")
For help on a given parameter, enter 'HELP SET ', followed by the
^ZKRX("HELP","SET","4")
name of the parameter, e.g. 'HELP SET LINE' for help on the
^ZKRX("HELP","SET","5")
'line' parameter.
^ZKRX("HELP","SET","6")

^ZKRX("HELP","SET","7")
Use the 'SHOW' command to see the current settings of all SETable
^ZKRX("HELP","SET","8")
parameters.
^ZKRX("HELP","SET","ABORTED-FILE","0")
9
^ZKRX("HELP","SET","ABORTED-FILE","1")
SET ABORTED-FILE
^ZKRX("HELP","SET","ABORTED-FILE","2")

^ZKRX("HELP","SET","ABORTED-FILE","3")
If transmission is aborted when receiving a file, what should be
^ZKRX("HELP","SET","ABORTED-FILE","4")
done with the partially-completed file?  The default (set when
^ZKRX("HELP","SET","ABORTED-FILE","5")
Kermit-M is initialized) is SET ABORTED-FILE DISCARD, which erases
^ZKRX("HELP","SET","ABORTED-FILE","6")
the file.
^ZKRX("HELP","SET","ABORTED-FILE","7")

^ZKRX("HELP","SET","ABORTED-FILE","8")
The other possibility is SET ABORTED-FILE KEEP, which closes the
^ZKRX("HELP","SET","ABORTED-FILE","9")
file and keeps it on the system.
^ZKRX("HELP","SET","BAUD","0")
8
^ZKRX("HELP","SET","BAUD","1")
SET BAUD
^ZKRX("HELP","SET","BAUD","2")

^ZKRX("HELP","SET","BAUD","3")
Use this command to set the baud rate of the port assigned in the
^ZKRX("HELP","SET","BAUD","4")
CONNECT or SET LINE command.  This command has no effect if we're
^ZKRX("HELP","SET","BAUD","5")
a remote Kermit.
^ZKRX("HELP","SET","BAUD","6")

^ZKRX("HELP","SET","BAUD","7")
Enter baud rates like '1200' or '9600'.  Enter SET BAUD ? for a list
^ZKRX("HELP","SET","BAUD","8")
of available baud reates.
^ZKRX("HELP","SET","DEBUGGING","0")
5
^ZKRX("HELP","SET","DEBUGGING","1")
SET DEBUGGING
^ZKRX("HELP","SET","DEBUGGING","2")

^ZKRX("HELP","SET","DEBUGGING","3")
If this is a local kermit, SET DEBUGGING ON will show the progress
^ZKRX("HELP","SET","DEBUGGING","4")
of Kermit transfers on the local screen.  SET DEBUGGING OFF (which
^ZKRX("HELP","SET","DEBUGGING","5")
is the default) will disable this.
^ZKRX("HELP","SET","DELAY","0")
10
^ZKRX("HELP","SET","DELAY","1")
SET DELAY
^ZKRX("HELP","SET","DELAY","2")

^ZKRX("HELP","SET","DELAY","3")
This allows you to specify the number of seconds that this remote
^ZKRX("HELP","SET","DELAY","4")
Kermit-M should wait before sending the first 'send intialize' packet
^ZKRX("HELP","SET","DELAY","5")
to your local Kermit.  This allows you time to 'escape' back to
^ZKRX("HELP","SET","DELAY","6")
your local Kermit and issue a RECEIVE command there.  The default is
^ZKRX("HELP","SET","DELAY","7")
5 seconds.
^ZKRX("HELP","SET","DELAY","8")

^ZKRX("HELP","SET","DELAY","9")
Generally, this shouldn't be necessary, as Kermit-M will retry if
^ZKRX("HELP","SET","DELAY","10")
the first several 'send intialize' attempts fail.
^ZKRX("HELP","SET","DUPLEX","0")
8
^ZKRX("HELP","SET","DUPLEX","1")
SET DUPLEX
^ZKRX("HELP","SET","DUPLEX","2")

^ZKRX("HELP","SET","DUPLEX","3")
Use this command to specify whether characters are echoed by the
^ZKRX("HELP","SET","DUPLEX","4")
local host (SET DUPLEX HALF) or by the remote host (SET DUPLEX FULL),
^ZKRX("HELP","SET","DUPLEX","5")
when connected from this Kermit-M to a remote host.
^ZKRX("HELP","SET","DUPLEX","6")

^ZKRX("HELP","SET","DUPLEX","7")
The default is FULL duplex, which works with DEC systems, etc.  HALF
^ZKRX("HELP","SET","DUPLEX","8")
duplex may be necessary for IBM hosts.
^ZKRX("HELP","SET","ESCAPE","0")
8
^ZKRX("HELP","SET","ESCAPE","1")
SET ESCAPE
^ZKRX("HELP","SET","ESCAPE","2")

^ZKRX("HELP","SET","ESCAPE","3")
If this is a local Kermit, and you want to CONNECT to a remote host,
^ZKRX("HELP","SET","ESCAPE","4")
there must be a way to break the connection and return to the local
^ZKRX("HELP","SET","ESCAPE","5")
host.  A control character, by default CTRL/Y (ASCII 25.), is used
^ZKRX("HELP","SET","ESCAPE","6")
for this.  The SET ESCAPE command allows you to change this.  Legal
^ZKRX("HELP","SET","ESCAPE","7")
values are ASCII 1 thru ASCII 31, entered as '^A' thru '^_', where
^ZKRX("HELP","SET","ESCAPE","8")
the '^' stands for 'Control'.
^ZKRX("HELP","SET","FILE-WARNING","0")
8
^ZKRX("HELP","SET","FILE-WARNING","1")
SET FILE-WARNING
^ZKRX("HELP","SET","FILE-WARNING","2")

^ZKRX("HELP","SET","FILE-WARNING","3")
This allows you to tell Kermit-M what action it should take if the
^ZKRX("HELP","SET","FILE-WARNING","4")
other Kermit tries to send it a file with the same name as one that
^ZKRX("HELP","SET","FILE-WARNING","5")
Kermit-M already has.  The default is SET FILE-WARNING OFF, which
^ZKRX("HELP","SET","FILE-WARNING","6")
causes Kermit-M to over-write any existing files.  The alternative
^ZKRX("HELP","SET","FILE-WARNING","7")
is SET FILE-WARNING ON, which causes Kermit-M to send an error
^ZKRX("HELP","SET","FILE-WARNING","8")
message back the other Kermit; the existing file is not changed.
^ZKRX("HELP","SET","LINE","0")
10
^ZKRX("HELP","SET","LINE","1")
SET LINE
^ZKRX("HELP","SET","LINE","2")

^ZKRX("HELP","SET","LINE","3")
This command establishes what port to use for a subsequent CONNECT
^ZKRX("HELP","SET","LINE","4")
command.  You can enter a MUMPS line number, or a mnemonic, e.g.
^ZKRX("HELP","SET","LINE","5")

^ZKRX("HELP","SET","LINE","6")
 SET LINE 104    or   SET LINE DEC20
^ZKRX("HELP","SET","LINE","7")

^ZKRX("HELP","SET","LINE","8")
Just the 'SET LINE' without any arguments will close any previously-
^ZKRX("HELP","SET","LINE","9")
established connection, and leave the port for CONNECT commands
^ZKRX("HELP","SET","LINE","10")
undefined.
^ZKRX("HELP","SET","PARITY","0")
14
^ZKRX("HELP","SET","PARITY","1")
SET PARITY
^ZKRX("HELP","SET","PARITY","2")

^ZKRX("HELP","SET","PARITY","3")
This command sets the parity on a port selected by the SET LINE or
^ZKRX("HELP","SET","PARITY","4")
CONNECT commands.  Use this to adjust to the communications protocol
^ZKRX("HELP","SET","PARITY","5")
of the host system, when running as a local Kermit.  Possible values
^ZKRX("HELP","SET","PARITY","6")
are EVEN, ODD, MARK, SPACE, or NONE.  Some of these may not be
^ZKRX("HELP","SET","PARITY","7")
available on all systems.  NONE is the default.
^ZKRX("HELP","SET","PARITY","8")

^ZKRX("HELP","SET","PARITY","9")
In M/11 V5, NONE and SPACE are the same (i.e. if NONE is specified,
^ZKRX("HELP","SET","PARITY","10")
the system zeroes the 8th bit, which is the same as SPACE), unless
^ZKRX("HELP","SET","PARITY","11")
binary files are being received (SET RECEIVE FILE-TYPE BINARY) or
^ZKRX("HELP","SET","PARITY","12")
sent, in which case all 8 bits are data.
^ZKRX("HELP","SET","PARITY","13")

^ZKRX("HELP","SET","PARITY","14")
In M/11 V5, MARK is not available.
^ZKRX("HELP","SET","PAUSE","0")
12
^ZKRX("HELP","SET","PAUSE","1")
SET PAUSE
^ZKRX("HELP","SET","PAUSE","2")

^ZKRX("HELP","SET","PAUSE","3")
This command sets the number of seconds to pause before sending
^ZKRX("HELP","SET","PAUSE","4")
a packet to the other Kermit.
^ZKRX("HELP","SET","PAUSE","5")

^ZKRX("HELP","SET","PAUSE","6")
This may be useful if the other system needs some 'turn around'
^ZKRX("HELP","SET","PAUSE","7")
time between the time it sends a packet, and when it is able to
^ZKRX("HELP","SET","PAUSE","8")
read our response (if we're receiving) or next packet (if we're
^ZKRX("HELP","SET","PAUSE","9")
sending).
^ZKRX("HELP","SET","PAUSE","10")

^ZKRX("HELP","SET","PAUSE","11")
The default is no pause.  The same pause is used whether we're
^ZKRX("HELP","SET","PAUSE","12")
sending or receiving files.
^ZKRX("HELP","SET","RECEIVE","0")
6
^ZKRX("HELP","SET","RECEIVE","1")
SET RECEIVE
^ZKRX("HELP","SET","RECEIVE","2")

^ZKRX("HELP","SET","RECEIVE","3")
Use this command to change various Kermit parameters when receiving
^ZKRX("HELP","SET","RECEIVE","4")
packets from the other Kermit.  Enter HELP SET RECEIVE ? for
^ZKRX("HELP","SET","RECEIVE","5")
a list of available subcommands, and HELP SET RECEIVE [subcommand]
^ZKRX("HELP","SET","RECEIVE","6")
for complete information on a subcommand.
^ZKRX("HELP","SET","RECEIVE","PACKET-LENGTH","0")
7
^ZKRX("HELP","SET","RECEIVE","PACKET-LENGTH","1")
SET RECEIVE PACKET-LENGTH
^ZKRX("HELP","SET","RECEIVE","PACKET-LENGTH","2")

^ZKRX("HELP","SET","RECEIVE","PACKET-LENGTH","3")
This command allows you to set the maximum number of characters
^ZKRX("HELP","SET","RECEIVE","PACKET-LENGTH","4")
that the other Kermit will send to us at a time.  This value can
^ZKRX("HELP","SET","RECEIVE","PACKET-LENGTH","5")
range from 10 to 94; the default is 64.  It is very important that
^ZKRX("HELP","SET","RECEIVE","PACKET-LENGTH","6")
this number not be greater than the size of our receiver buffer;
^ZKRX("HELP","SET","RECEIVE","PACKET-LENGTH","7")
otherwise we will lose some characters in each packet.
^ZKRX("HELP","SET","RECEIVE","START-OF-PACKET","0")
11
^ZKRX("HELP","SET","RECEIVE","START-OF-PACKET","1")
SET RECEIVE START-OF-PACKET
^ZKRX("HELP","SET","RECEIVE","START-OF-PACKET","2")

^ZKRX("HELP","SET","RECEIVE","START-OF-PACKET","3")
If the other end can't transmit the standard start-of-packet, which
^ZKRX("HELP","SET","RECEIVE","START-OF-PACKET","4")
is an ASCII 1. (also called <SOH> or ^A), you must tell this Kermit
^ZKRX("HELP","SET","RECEIVE","START-OF-PACKET","5")
what start-of-packet character the other end will transmit to us,
^ZKRX("HELP","SET","RECEIVE","START-OF-PACKET","6")
using this command.
^ZKRX("HELP","SET","RECEIVE","START-OF-PACKET","7")

^ZKRX("HELP","SET","RECEIVE","START-OF-PACKET","8")
Any control character from 1.-31. is acceptable; enter like '^A'.
^ZKRX("HELP","SET","RECEIVE","START-OF-PACKET","9")

^ZKRX("HELP","SET","RECEIVE","START-OF-PACKET","10")
If the other end can't transmit SOH, it probably can't receive it
^ZKRX("HELP","SET","RECEIVE","START-OF-PACKET","11")
either; see SET SEND START-OF-PACKET.
^ZKRX("HELP","SET","RECEIVE","TIMEOUT","0")
9
^ZKRX("HELP","SET","RECEIVE","TIMEOUT","1")
SET RECEIVE TIMEOUT
^ZKRX("HELP","SET","RECEIVE","TIMEOUT","2")

^ZKRX("HELP","SET","RECEIVE","TIMEOUT","3")
Use this command to tell Kermit how many seconds to wait before
^ZKRX("HELP","SET","RECEIVE","TIMEOUT","4")
'timing out' when waiting for a packet from the other packet.  This
^ZKRX("HELP","SET","RECEIVE","TIMEOUT","5")
sets our default (which is initialized to 16); note that the other
^ZKRX("HELP","SET","RECEIVE","TIMEOUT","6")
Kermit can change this in its 'send initialize' packet (if it's
^ZKRX("HELP","SET","RECEIVE","TIMEOUT","7")
sending files) or in its 'acknowledgement' to our 'send initialize'.
^ZKRX("HELP","SET","RECEIVE","TIMEOUT","8")

^ZKRX("HELP","SET","RECEIVE","TIMEOUT","9")
See also SET SEND TIMEOUT
^ZKRX("HELP","SET","RETRY","0")
6
^ZKRX("HELP","SET","RETRY","1")
SET RETRY
^ZKRX("HELP","SET","RETRY","2")

^ZKRX("HELP","SET","RETRY","3")
Set the maximum number of times that Kermit-M will retry an operation
^ZKRX("HELP","SET","RETRY","4")
before giving up and aborting the transfer.  The same number of tries
^ZKRX("HELP","SET","RETRY","5")
are used for initial connection and for each packet.  The default is
^ZKRX("HELP","SET","RETRY","6")
8 total tries (i.e. 7 retries).  Any integer from 0 up can be used.
^ZKRX("HELP","SET","SEND","0")
22
^ZKRX("HELP","SET","SEND","1")
SET SEND
^ZKRX("HELP","SET","SEND","2")

^ZKRX("HELP","SET","SEND","3")
This allows you to set parameters to be used by Kermit when sending
^ZKRX("HELP","SET","SEND","4")
packets to another Kermit.  PACKET-LENGTH, TIMEOUT, and END-OF-LINE
^ZKRX("HELP","SET","SEND","5")
may be changed by the other Kermit in their 'send intialize'
^ZKRX("HELP","SET","SEND","6")
packet (if they're sending files) or in their acknowledgement to our
^ZKRX("HELP","SET","SEND","7")
'send initialize' packet (if they're receiving files); the quote
^ZKRX("HELP","SET","SEND","8")
character is '#' if they don't specify one.
^ZKRX("HELP","SET","SEND","9")

^ZKRX("HELP","SET","SEND","10")
START-OF-PACKET must be set correctly before the first packet can be
^ZKRX("HELP","SET","SEND","11")
received by the other Kermit; if the other Kermit needs a line
^ZKRX("HELP","SET","SEND","12")
terminator, so must END-OF-LINE.
^ZKRX("HELP","SET","SEND","13")

^ZKRX("HELP","SET","SEND","14")
 SET SEND END-OF-LINE.  The control character, entered like '^M',
^ZKRX("HELP","SET","SEND","15")
   that the other end needs to terminate each packet.  Default ASCII
^ZKRX("HELP","SET","SEND","16")
   13. (<CR>, ^M).
^ZKRX("HELP","SET","SEND","17")
 SET SEND PACKET-LENGTH.  Default is 80.
^ZKRX("HELP","SET","SEND","18")
 SET SEND START-OF-PACKET.  The control character, entered like '^A',
^ZKRX("HELP","SET","SEND","19")
   that the other end recognizes as starting each packet.  Default
^ZKRX("HELP","SET","SEND","20")
   ASCII 1 (<SOH>, ^A).
^ZKRX("HELP","SET","SEND","21")
 SET SEND TIMEOUT.  The number of seconds after which the other end
^ZKRX("HELP","SET","SEND","22")
   wishes to be timed out.  Default is 16 seconds.
^ZKRX("HELP","SET","SEND","END-OF-LINE","0")
11
^ZKRX("HELP","SET","SEND","END-OF-LINE","1")
SET SEND END-OF-LINE
^ZKRX("HELP","SET","SEND","END-OF-LINE","2")

^ZKRX("HELP","SET","SEND","END-OF-LINE","3")
Use this command to tell this Kermit how to terminate outgoing
^ZKRX("HELP","SET","SEND","END-OF-LINE","4")
packets.  The default is to append an ASCII 13., i.e. a carriage
^ZKRX("HELP","SET","SEND","END-OF-LINE","5")
return character, to each line.  The other Kermit may want some
^ZKRX("HELP","SET","SEND","END-OF-LINE","6")
other character.
^ZKRX("HELP","SET","SEND","END-OF-LINE","7")

^ZKRX("HELP","SET","SEND","END-OF-LINE","8")
Enter the end-of-line character like '^M' for CTRL/M (i.e. <CR>).
^ZKRX("HELP","SET","SEND","END-OF-LINE","9")

^ZKRX("HELP","SET","SEND","END-OF-LINE","10")
Note that Kermit-M does not require a line terminator; if one is
^ZKRX("HELP","SET","SEND","END-OF-LINE","11")
sent, it is discarded.
^ZKRX("HELP","SET","SEND","PACKET-LENGTH","0")
13
^ZKRX("HELP","SET","SEND","PACKET-LENGTH","1")
SET SEND PACKET-LENGTH
^ZKRX("HELP","SET","SEND","PACKET-LENGTH","2")

^ZKRX("HELP","SET","SEND","PACKET-LENGTH","3")
Use this command to tell this Kermit the maximum number of character
^ZKRX("HELP","SET","SEND","PACKET-LENGTH","4")
to put in each outgoing packets.  Any integer from 10 thru 94 is
^ZKRX("HELP","SET","SEND","PACKET-LENGTH","5")
allowed.  Note that the other Kermit may request a different maximum
^ZKRX("HELP","SET","SEND","PACKET-LENGTH","6")
value from us in its 'send-intialize' packet (if its sending files)
^ZKRX("HELP","SET","SEND","PACKET-LENGTH","7")
or in its 'acknowledgement' to our 'send-intialize'; the smaller of
^ZKRX("HELP","SET","SEND","PACKET-LENGTH","8")
of the two values is used.
^ZKRX("HELP","SET","SEND","PACKET-LENGTH","9")

^ZKRX("HELP","SET","SEND","PACKET-LENGTH","10")
This value must be smaller than the maximum number of characters
^ZKRX("HELP","SET","SEND","PACKET-LENGTH","11")
which might be in this system's transmit buffer at a time.  The other
^ZKRX("HELP","SET","SEND","PACKET-LENGTH","12")
Kermit might be able to handle full-length packets, but this Kermit's
^ZKRX("HELP","SET","SEND","PACKET-LENGTH","13")
transmit buffer might be too small.
^ZKRX("HELP","SET","SEND","QUOTE","0")
15
^ZKRX("HELP","SET","SEND","QUOTE","1")
SET SEND QUOTE
^ZKRX("HELP","SET","SEND","QUOTE","2")

^ZKRX("HELP","SET","SEND","QUOTE","3")
Use this command to specify what printable character shall be used
^ZKRX("HELP","SET","SEND","QUOTE","4")
to 'quote' control characters.  The default is '#'; you might want
^ZKRX("HELP","SET","SEND","QUOTE","5")
to change it to reduce the amount of quoting in the transmitted
^ZKRX("HELP","SET","SEND","QUOTE","6")
file.  However, some other Kermits may not be able to use another
^ZKRX("HELP","SET","SEND","QUOTE","7")
quote character, which will cause unusual looking files on the
^ZKRX("HELP","SET","SEND","QUOTE","8")
other system.
^ZKRX("HELP","SET","SEND","QUOTE","9")

^ZKRX("HELP","SET","SEND","QUOTE","10")
Note that when we're receiving, the other Kermit tells us what
^ZKRX("HELP","SET","SEND","QUOTE","11")
'quote' character will be used; there is no way to change it here.
^ZKRX("HELP","SET","SEND","QUOTE","12")

^ZKRX("HELP","SET","SEND","QUOTE","13")
The 'quote' character can be any character with an ASCII value in
^ZKRX("HELP","SET","SEND","QUOTE","14")
the range 33. -> 62. or 96. -> 126..  This includes most punctuation
^ZKRX("HELP","SET","SEND","QUOTE","15")
and all lower case letters and digits.
^ZKRX("HELP","SET","SEND","START-OF-PACKET","0")
11
^ZKRX("HELP","SET","SEND","START-OF-PACKET","1")
SET SEND START-OF-PACKET
^ZKRX("HELP","SET","SEND","START-OF-PACKET","2")

^ZKRX("HELP","SET","SEND","START-OF-PACKET","3")
If the other end can't receive the standard start-of-packet, which
^ZKRX("HELP","SET","SEND","START-OF-PACKET","4")
is an ASCII 1. (also called <SOH> or ^A), you must tell this Kermit
^ZKRX("HELP","SET","SEND","START-OF-PACKET","5")
what start-of-packet character the other end expects from us,
^ZKRX("HELP","SET","SEND","START-OF-PACKET","6")
using this command.
^ZKRX("HELP","SET","SEND","START-OF-PACKET","7")

^ZKRX("HELP","SET","SEND","START-OF-PACKET","8")
Any control character from 1.-31. is acceptable; enter like '^A'.
^ZKRX("HELP","SET","SEND","START-OF-PACKET","9")

^ZKRX("HELP","SET","SEND","START-OF-PACKET","10")
If the other end can't receive SOH, it probably can't send it
^ZKRX("HELP","SET","SEND","START-OF-PACKET","11")
either; see SET RECEIVE START-OF-PACKET.
^ZKRX("HELP","SET","SEND","TIMEOUT","0")
9
^ZKRX("HELP","SET","SEND","TIMEOUT","1")
SET SEND TIMEOUT
^ZKRX("HELP","SET","SEND","TIMEOUT","2")

^ZKRX("HELP","SET","SEND","TIMEOUT","3")
Use this command to tell the other Kermit how many seconds to
^ZKRX("HELP","SET","SEND","TIMEOUT","4")
wait for each packet before 'timing out'.  There is no default for
^ZKRX("HELP","SET","SEND","TIMEOUT","5")
this command; the other system uses its default unless you change
^ZKRX("HELP","SET","SEND","TIMEOUT","6")
it here.  Note that some other Kermits (e.g. micros) can't time
^ZKRX("HELP","SET","SEND","TIMEOUT","7")
out, in which case this command has no effect.
^ZKRX("HELP","SET","SEND","TIMEOUT","8")

^ZKRX("HELP","SET","SEND","TIMEOUT","9")
See also SET RECEIVE TIMEOUT.
^ZKRX("HELP","SHOW","0")
4
^ZKRX("HELP","SHOW","1")
SHOW
^ZKRX("HELP","SHOW","2")

^ZKRX("HELP","SHOW","3")
Display the current SET parameters, version of Kermit-M, and other
^ZKRX("HELP","SHOW","4")
information.
^ZKRX("HELP","STATISTICS","0")
4
^ZKRX("HELP","STATISTICS","1")
STATISTICS
^ZKRX("HELP","STATISTICS","2")

^ZKRX("HELP","STATISTICS","3")
Shows the number of bytes and the transfer rate of the most recent
^ZKRX("HELP","STATISTICS","4")
file transfer.  Only data bytes (and any quotes) are counted.
^ZKRX("LINE","MODEM1")
102
^ZKRX("LINE","MODEM2")
104
^ZKRX("MHELP","IOPT","0")
17
^ZKRX("MHELP","IOPT","1")
Kermit-M File System -- INPUT Options
^ZKRX("MHELP","IOPT","2")

^ZKRX("MHELP","IOPT","3")
Enter the number of the input option you want; press <CR> only to
^ZKRX("MHELP","IOPT","4")
 return to the Kermit-M File System MAIN Options.  Choices are:
^ZKRX("MHELP","IOPT","5")

^ZKRX("MHELP","IOPT","6")
 1 - Sequential file in (includes 'print', 'type', 'list').
^ZKRX("MHELP","IOPT","7")
 2 - Routine in from .MMP files (Micro-MUMPS routines)
^ZKRX("MHELP","IOPT","8")
 3 - Routine in from a Kermit-M .ROU file
^ZKRX("MHELP","IOPT","9")
 4 - Global in
^ZKRX("MHELP","IOPT","10")
 5 - Sequential global in
^ZKRX("MHELP","IOPT","11")

^ZKRX("MHELP","IOPT","12")
These choices are the inverse operations of the OUTPUT Options by the
^ZKRX("MHELP","IOPT","13")
same numbers; i.e., files written with the corresponding OUTPUT Option
^ZKRX("MHELP","IOPT","14")
will be restored by the correct INPUT Option.
^ZKRX("MHELP","IOPT","15")

^ZKRX("MHELP","IOPT","16")
For more information on each choice, enter the number followed by a
^ZKRX("MHELP","IOPT","17")
question mark, e.g. '4?' to get more information on 'Global in'.
^ZKRX("MHELP","IOPT","GI","0")
15
^ZKRX("MHELP","IOPT","GI","1")
Kermit-M File System - INPUT Options - Global in
^ZKRX("MHELP","IOPT","GI","2")

^ZKRX("MHELP","IOPT","GI","3")
This option interpets a Kermit-M file as pairs of lines, the first representing
^ZKRX("MHELP","IOPT","GI","4")
 the global reference, and the second the data to be put in that reference.
^ZKRX("MHELP","IOPT","GI","5")
 An illegal global reference (e.g. a null line) ends the input.  For example:
^ZKRX("MHELP","IOPT","GI","6")

^ZKRX("MHELP","IOPT","GI","7")
  odd-# line:   ^A("ACC",521,"A","BAL")
^ZKRX("MHELP","IOPT","GI","8")
  even-# line:  123.41.0-10.20Warning
^ZKRX("MHELP","IOPT","GI","9")

^ZKRX("MHELP","IOPT","GI","10")
This would set the contents of the even-# line into the node given as a
^ZKRX("MHELP","IOPT","GI","11")
 reference in the odd-# line.
^ZKRX("MHELP","IOPT","GI","12")

^ZKRX("MHELP","IOPT","GI","13")
There is NO check for previously-existing data.  Thus any data in the file
^ZKRX("MHELP","IOPT","GI","14")
 will over-write data already on-line; the result may be to merge the data
^ZKRX("MHELP","IOPT","GI","15")
 from the Kermit-M file with existing data.
^ZKRX("MHELP","IOPT","RIM","0")
14
^ZKRX("MHELP","IOPT","RIM","1")
Kermit-M File System - INPUT Options - Routine In (.MMP files)
^ZKRX("MHELP","IOPT","RIM","2")

^ZKRX("MHELP","IOPT","RIM","3")
This option interprets one or more *.MMP files as MUMPS routines, and files
^ZKRX("MHELP","IOPT","RIM","4")
 them in this MUMPS system.  Each *.MMP file contains one routine, with no
^ZKRX("MHELP","IOPT","RIM","5")
 header or 'external' comments.  Generally, these files are created on Micro-
^ZKRX("MHELP","IOPT","RIM","6")
 MUMPS systems.  These will be filed on our system using the 'file name'
^ZKRX("MHELP","IOPT","RIM","7")
 portion of the filespec; e.g. if the Kermit-M file is named 'AAA.MMP', its
^ZKRX("MHELP","IOPT","RIM","8")
 contents will be filed as routine AAA.
^ZKRX("MHELP","IOPT","RIM","9")

^ZKRX("MHELP","IOPT","RIM","10")
If you select this option, you will be asked for the filespec of one or more
^ZKRX("MHELP","IOPT","RIM","11")
 Kermit-M files.  The 'file type' must be 'MMP'.  As each routine is saved
^ZKRX("MHELP","IOPT","RIM","12")
 from the corresponding Kermit-M file, you will be informed if a routine
^ZKRX("MHELP","IOPT","RIM","13")
 by that name is already filed on this system; you have the option of
^ZKRX("MHELP","IOPT","RIM","14")
 over-writing or not.
^ZKRX("MHELP","IOPT","RIR","0")
18
^ZKRX("MHELP","IOPT","RIR","1")
Kermit-M File System - INPUT Options - Routine in (.ROU file)
^ZKRX("MHELP","IOPT","RIR","2")

^ZKRX("MHELP","IOPT","RIR","3")
This option interprets one *.ROU file as a set of MUMPS routines, written
^ZKRX("MHELP","IOPT","RIR","4")
 by option 3 of the OUTPUT Options (or an equivalent program).  The file must
^ZKRX("MHELP","IOPT","RIR","5")
 have the following format:
^ZKRX("MHELP","IOPT","RIR","6")

^ZKRX("MHELP","IOPT","RIR","7")
  Free-text description
^ZKRX("MHELP","IOPT","RIR","8")
  Date & time file was written
^ZKRX("MHELP","IOPT","RIR","9")
  Routine 1
^ZKRX("MHELP","IOPT","RIR","10")
  (null line)
^ZKRX("MHELP","IOPT","RIR","11")
  ..............any number of routines here
^ZKRX("MHELP","IOPT","RIR","12")
  (additional null line)
^ZKRX("MHELP","IOPT","RIR","13")

^ZKRX("MHELP","IOPT","RIR","14")
Each routine is preceded a single line containing its name; the 'line start'
^ZKRX("MHELP","IOPT","RIR","15")
 is represented by a space.
^ZKRX("MHELP","IOPT","RIR","16")

^ZKRX("MHELP","IOPT","RIR","17")
If any routine to be input is already on file, you will be asked if you really
^ZKRX("MHELP","IOPT","RIR","18")
 want to over-write it.
^ZKRX("MHELP","IOPT","SFI","0")
17
^ZKRX("MHELP","IOPT","SFI","1")
Kermit-M File System - INPUT Options - Sequential File In
^ZKRX("MHELP","IOPT","SFI","2")

^ZKRX("MHELP","IOPT","SFI","3")
This option will interpet Kermit-M files as a sequence of text lines,
^ZKRX("MHELP","IOPT","SFI","4")
 separated by (quoted) <CR><LF> combinations in the file.
^ZKRX("MHELP","IOPT","SFI","5")

^ZKRX("MHELP","IOPT","SFI","6")
If you select this option, you will be asked to designate a MUMPS sequential
^ZKRX("MHELP","IOPT","SFI","7")
 device to which the sequential file should be directed.  For example, if
^ZKRX("MHELP","IOPT","SFI","8")
 you select this terminal, the file will be 'typed' onto it; if you
^ZKRX("MHELP","IOPT","SFI","9")
 select a line printer, the file will be 'printed'.  Other choices are
^ZKRX("MHELP","IOPT","SFI","10")
 magnetic tape (MT) or sequential disk processor (SDP).
^ZKRX("MHELP","IOPT","SFI","11")

^ZKRX("MHELP","IOPT","SFI","12")
If you type or print the files, each separate Kermit-M file will be preceded
^ZKRX("MHELP","IOPT","SFI","13")
 by a header, showing the file name, size, and time received.  On a printer,
^ZKRX("MHELP","IOPT","SFI","14")
 each file will start on a new page.  On MT or SDP, however, all files will
^ZKRX("MHELP","IOPT","SFI","15")
 be catenated with no delimiters, and the sequential file will end with a
^ZKRX("MHELP","IOPT","SFI","16")
 text line consisting only of a CTRL/Z.  In addition, files written to MT
^ZKRX("MHELP","IOPT","SFI","17")
 will be followed by a single hardware EOF (tape mark).
^ZKRX("MHELP","IOPT","SGI","0")
18
^ZKRX("MHELP","IOPT","SGI","1")
Kermit-M File System - INPUT Options - Sequential global in
^ZKRX("MHELP","IOPT","SGI","2")

^ZKRX("MHELP","IOPT","SGI","3")
This option interprets any Kermit-M file as a sequence of text lines (separated
^ZKRX("MHELP","IOPT","SGI","4")
 by <CR><LF>), and files them at subscripts from 1:1... below any global node.
^ZKRX("MHELP","IOPT","SGI","5")
 If you select this option, you will be asked to specify the root of a global
^ZKRX("MHELP","IOPT","SGI","6")
 subtree, under which the sequence of lines will be filed.  E.g. if you select:
^ZKRX("MHELP","IOPT","SGI","7")

^ZKRX("MHELP","IOPT","SGI","8")
     Root: ^A(32584,9900)
^ZKRX("MHELP","IOPT","SGI","9")

^ZKRX("MHELP","IOPT","SGI","10")
 then the lines of text will be stored as:
^ZKRX("MHELP","IOPT","SGI","11")

^ZKRX("MHELP","IOPT","SGI","12")
   ^A(32584,9900,1)=first line of text
^ZKRX("MHELP","IOPT","SGI","13")
   ^A(32584,9900,2)=second line of text
^ZKRX("MHELP","IOPT","SGI","14")
   .
^ZKRX("MHELP","IOPT","SGI","15")
   ... (etc.)
^ZKRX("MHELP","IOPT","SGI","16")

^ZKRX("MHELP","IOPT","SGI","17")
The root that you specify may be defined, but it must not already have
^ZKRX("MHELP","IOPT","SGI","18")
 descendents.
^ZKRX("MHELP","MOPT","0")
19
^ZKRX("MHELP","MOPT","1")
Kermit-M File System -- Main options
^ZKRX("MHELP","MOPT","2")

^ZKRX("MHELP","MOPT","3")
Enter the single letter for the File System Option you want.  Choices are:
^ZKRX("MHELP","MOPT","4")

^ZKRX("MHELP","MOPT","5")
 X -- eXit; return to the Kermit-M command level
^ZKRX("MHELP","MOPT","6")

^ZKRX("MHELP","MOPT","7")
 D -- DIRECTORY of files in the File System
^ZKRX("MHELP","MOPT","8")
 E -- ERASE one or more files from the File System
^ZKRX("MHELP","MOPT","9")
 R -- RENAME one or more files within the File System
^ZKRX("MHELP","MOPT","10")
 C -- COPY one or more files within the File System
^ZKRX("MHELP","MOPT","11")

^ZKRX("MHELP","MOPT","12")
 I -- dispatch to the INPUT options.  These allow you to move information from
^ZKRX("MHELP","MOPT","13")
       the Kermit-M File System 'into' MUMPS data structures; presumably the
^ZKRX("MHELP","MOPT","14")
      Kermit-M files were obtained from other systems (e.g. with the Kermit-M
^ZKRX("MHELP","MOPT","15")
      RECEIVE command).
^ZKRX("MHELP","MOPT","16")

^ZKRX("MHELP","MOPT","17")
 O -- dispatch to the OUTPUT options.  These allow you to move information from
^ZKRX("MHELP","MOPT","18")
       MUMPS data structures 'out to' the Kermit-M File System, from which
^ZKRX("MHELP","MOPT","19")
       they can be sent to other systems (e.g. with the Kermit-M SEND command).
^ZKRX("MHELP","OOPT","0")
17
^ZKRX("MHELP","OOPT","1")
Kermit-M File System -- OUTPUT Options
^ZKRX("MHELP","OOPT","2")

^ZKRX("MHELP","OOPT","3")
Enter the number of the output option you want; press <CR> only to
^ZKRX("MHELP","OOPT","4")
 return to the Kermit-M File System MAIN Options.  Choices are:
^ZKRX("MHELP","OOPT","5")

^ZKRX("MHELP","OOPT","6")
 1 - Sequential file out ('read' a file to output).
^ZKRX("MHELP","OOPT","7")
 2 - Routine out to .MMP files (Micro-MUMPS routines)
^ZKRX("MHELP","OOPT","8")
 3 - Routine out to a Kermit-M .ROU file
^ZKRX("MHELP","OOPT","9")
 4 - Global out
^ZKRX("MHELP","OOPT","10")
 5 - Sequential global out (one level of a global).
^ZKRX("MHELP","OOPT","11")

^ZKRX("MHELP","OOPT","12")
These choices are the inverse operations of the INPUT Options by the
^ZKRX("MHELP","OOPT","13")
same numbers; i.e., files written with one of these OUTPUT Options
^ZKRX("MHELP","OOPT","14")
can be restored by the INPUT Option by the same number.
^ZKRX("MHELP","OOPT","15")

^ZKRX("MHELP","OOPT","16")
For more information on each choice, enter the number followed by a
^ZKRX("MHELP","OOPT","17")
question mark, e.g. '4?' to get more information on 'Global out.
^ZKRX("MHELP","OOPT","GO","0")
18
^ZKRX("MHELP","OOPT","GO","1")
Kermit-M File System - OUTPUT Options - Global out
^ZKRX("MHELP","OOPT","GO","2")

^ZKRX("MHELP","OOPT","GO","3")
 This option writes any global subtree to a Kermit-M file, in a format that
^ZKRX("MHELP","OOPT","GO","4")
 can be read with input option 4 (global in).  If you select this option,
^ZKRX("MHELP","OOPT","GO","5")
 you will be asked to specify the root of a global subtree (which may be
^ZKRX("MHELP","OOPT","GO","6")
 an entire global).  The root and all descendents will be written to the file
^ZKRX("MHELP","OOPT","GO","7")
 in 'preorder'.  Two lines are written for each data node: the odd-# lines
^ZKRX("MHELP","OOPT","GO","8")
 contain the full global reference, and the following even-# lines contain
^ZKRX("MHELP","OOPT","GO","9")
 the data for that reference.  A null line ends the file.
^ZKRX("MHELP","OOPT","GO","10")

^ZKRX("MHELP","OOPT","GO","11")
For example, if we had the following global node:
^ZKRX("MHELP","OOPT","GO","12")

^ZKRX("MHELP","OOPT","GO","13")
 ^A("AAC",521,"A","BAL")=123.41.0-10.20Warning
^ZKRX("MHELP","OOPT","GO","14")

^ZKRX("MHELP","OOPT","GO","15")
 we would write the following two lines to the Kermit-M file:
^ZKRX("MHELP","OOPT","GO","16")

^ZKRX("MHELP","OOPT","GO","17")
 odd-# line:   ^A("AAC",521,"A","BAL")
^ZKRX("MHELP","OOPT","GO","18")
 even-# line:  123.41.0-10.20Warning
^ZKRX("MHELP","OOPT","ROM","0")
9
^ZKRX("MHELP","OOPT","ROM","1")
Kermit-M File System - OUTPUT Options - Routine Out (.MMP files)
^ZKRX("MHELP","OOPT","ROM","2")

^ZKRX("MHELP","OOPT","ROM","3")
This option writes one or more MUMPS routines to Kermit-M files.  Each MUMPS
^ZKRX("MHELP","OOPT","ROM","4")
 routine that you specify will be written to a separate file, with a 'file
^ZKRX("MHELP","OOPT","ROM","5")
 name' that is the same as the routine name, and a file type of 'MMP'.  For
^ZKRX("MHELP","OOPT","ROM","6")
 example, routine AAA would be written to Kermit-M file 'AAA.MMP'.
^ZKRX("MHELP","OOPT","ROM","7")

^ZKRX("MHELP","OOPT","ROM","8")
Existing files, if any, are not overwritten.  You can use the (R)ename
^ZKRX("MHELP","OOPT","ROM","9")
 option in the MAIN Options to remove any conflicts.
^ZKRX("MHELP","OOPT","ROR","0")
15
^ZKRX("MHELP","OOPT","ROR","1")
Kermit-M File System - OUTPUT Options - Routine out (.ROU file)
^ZKRX("MHELP","OOPT","ROR","2")

^ZKRX("MHELP","OOPT","ROR","3")
This option creates a *.ROU file from a set of MUMPS routines, in a format
^ZKRX("MHELP","OOPT","ROR","4")
 that can be interpreted by option 3 of the INPUT Options (or an equivalent
^ZKRX("MHELP","OOPT","ROR","5")
 program).  The file has the following format:
^ZKRX("MHELP","OOPT","ROR","6")

^ZKRX("MHELP","OOPT","ROR","7")
  Free-text description
^ZKRX("MHELP","OOPT","ROR","8")
  Date & time file was written
^ZKRX("MHELP","OOPT","ROR","9")
  Routine 1
^ZKRX("MHELP","OOPT","ROR","10")
  (null line)
^ZKRX("MHELP","OOPT","ROR","11")
  ..............any number of routines here
^ZKRX("MHELP","OOPT","ROR","12")
  (additional null line)
^ZKRX("MHELP","OOPT","ROR","13")

^ZKRX("MHELP","OOPT","ROR","14")
Each routine is preceded a single line containing its name; the 'line start'
^ZKRX("MHELP","OOPT","ROR","15")
 is represented by a space.
^ZKRX("MHELP","OOPT","SFO","0")
12
^ZKRX("MHELP","OOPT","SFO","1")
Kermit-M File System - OUTPUT Options - Sequential File Out
^ZKRX("MHELP","OOPT","SFO","2")

^ZKRX("MHELP","OOPT","SFO","3")
This option will write text from a MUMPS sequential device to a Kermit-M file.
^ZKRX("MHELP","OOPT","SFO","4")
 Records (i.e. results of separate READ statements) are separated by <CR><LF>
^ZKRX("MHELP","OOPT","SFO","5")
 line terminators in the Kermit-M file.
^ZKRX("MHELP","OOPT","SFO","6")

^ZKRX("MHELP","OOPT","SFO","7")
If you select this option, you will be asked to designate a MUMPS sequential
^ZKRX("MHELP","OOPT","SFO","8")
 device from which the sequential file should be read.  For example, if
^ZKRX("MHELP","OOPT","SFO","9")
 you select this terminal, the file will be read directly from the keyboard.
^ZKRX("MHELP","OOPT","SFO","10")
 Other choices are magtape (MT) or sequential disk processor (SDP).  Files on
^ZKRX("MHELP","OOPT","SFO","11")
 MT and SDP end with a single line containing only a CTRL/Z.  In addition,
^ZKRX("MHELP","OOPT","SFO","12")
 a hardware EOF (tape mark) can end a file on MT.
^ZKRX("MHELP","OOPT","SGO","0")
17
^ZKRX("MHELP","OOPT","SGO","1")
Kermit-M File System - OUTPUT Options - Sequential global out
^ZKRX("MHELP","OOPT","SGO","2")

^ZKRX("MHELP","OOPT","SGO","3")
This option interprets one level of any global subtree as a sequence of text
^ZKRX("MHELP","OOPT","SGO","4")
 lines, and writes them to a Kermit-M file.  If you select this option, you
^ZKRX("MHELP","OOPT","SGO","5")
 will be asked to specify the root of a global subtree, and a Kermit-M file
^ZKRX("MHELP","OOPT","SGO","6")
 name to write.
^ZKRX("MHELP","OOPT","SGO","7")

^ZKRX("MHELP","OOPT","SGO","8")
All nodes in the first level below the specified root will be written, in
^ZKRX("MHELP","OOPT","SGO","9")
 collated order.  For example, given this subfile:
^ZKRX("MHELP","OOPT","SGO","10")

^ZKRX("MHELP","OOPT","SGO","11")
 ^A(1,2)=this is the root
^ZKRX("MHELP","OOPT","SGO","12")
 ^A(1,2,1.2)=line 1
^ZKRX("MHELP","OOPT","SGO","13")
 ^A(1,2,20)=line 2
^ZKRX("MHELP","OOPT","SGO","14")
 ^A(1,2,"A STRING")=line 3
^ZKRX("MHELP","OOPT","SGO","15")

^ZKRX("MHELP","OOPT","SGO","16")
 the three lines (NOT including the root) will be written in order.  Note
^ZKRX("MHELP","OOPT","SGO","17")
 that NO lower levels (if any) will be written.
^ZKRX("VERSION")
1.0